搭建前端环境

注册微信开发者账号

打开微信公总平台，按照流程一步步注册：https://mp.weixin.qq.com/

然后去申请开通三个我们项目会用到的接口
![[Pasted image 20250417092751.png]]

以及我们需要用到的插件
![[Pasted image 20250417093027.png]]
https://fuwu.weixin.qq.com/search?tab=3&type=&serviceType=3&page=1&kw=腾讯位置服务地图选点
fuwu.weixin.qq.com/search?tab=3&type=&serviceType=3&page=1&kw=微信同声传译

安装 node.js 和微信开发者工具

下载node.js：https://nodejs.org/en/download 版本选择16.20.0
![[Pasted image 20250417093149.png]]

微信开发者工具也是点击下载一步步走就行

• 下载两遍，安装两个相同的，方便后期项目两个端口一起调试
  ![[Pasted image 20250417091648.png]]
  ![[Pasted image 20250417091741.png]]

在开发者工具中运行前端代码

• 点击左上角项目栏下的导入项目
  ![[Pasted image 20250417093655.png]]

• 点击上方设置栏中的安全设置，打开里面的服务端口
  ![[Pasted image 20250417093936.png]]

另一个也是一样

搭建后端环境

安装软件环境

安装rabbitmq

• **第一步 拉取镜像

`docker pull rabbitmq:3.9.0-management

• **第二步 使用容器启动服务

`docker run -d –name=rabbitmq –restart=always -p 5672:5672 -p 15672:15672 rabbitmq:3.9.0-management  

• **第三步 安装延迟队列插件

1、首先下载rabbitmq_delayed_message_exchange-3.9.0.ez文件上传到RabbitMQ所在服务器，下载地址：https://www.rabbitmq.com/community-plugins.html

2、上传下载延迟队列插件到Linux操作系统中，切换到插件所在目录，

执行 docker cp rabbitmq_delayed_message_exchange-3.9.0.ez rabbitmq:/plugins 命令，将刚插件拷贝到容器内plugins目录下

3、执行 docker exec -it rabbitmq /bin/bash 命令进入到容器内部，并 cd plugins 进入plugins目录

执行 ls -l|grep delay  命令查看插件是否copy成功
在容器内plugins目录下，执行 rabbitmq-plugins enable rabbitmq_delayed_message_exchange  命令启用插件

4、exit命令退出RabbitMQ容器内部，然后执行 docker restart rabbitmq 命令重启RabbitMQ容器

• **第四步 远程访问设置凭证

  1 2 3 4 5 6 7 8 9 10 11

  # 进入容器 docker exec -it rabbitmq bash # 创建新用户（用户名：admin，密码：Abc123） rabbitmqctl add_user admin Abc123 # 赋予管理员权限 rabbitmqctl set_user_tags admin administrator # 赋予所有权限（虚拟主机为 /） rabbitmqctl set_permissions -p / admin ".*" ".*" ".*"

安装redis

• **第一步 拉取镜像

docker pull redis

• **第二步 创建Redis配置文件

1
2
3
4

## 创建目录
mkdir -p /home/redis/conf
## 创建文件
touch /home/redis/conf/redis.conf

• **第三步 创建redis并启动

1
2
3
4
5
6
7
8

docker run -d \
  --name redis \
  -p 6379:6379 \
  --restart unless-stopped \
  -v /home/redis/data:/data \
  -v /home/redis/conf/redis.conf:/etc/redis/redis.conf \
  redis:latest \
  redis-server /etc/redis/redis.conf

• **第四步 进入redis容器

1
2
3
4
5
6
7
8

### 直接通过Docker Redis 命令进入Redis控制台
docker exec -it redis redis-cli
### 进入 Redis 控制台
redis-cli
### 添加一个变量为 key 为 name , value 为 bella 的内容
> set name bella
### 查看 key 为 name 的 value 值
> get name

安装minio

1
2
3
4
5
6
7
8
9
10

 docker run \
--name minio_one \
-p 9000:9000  \
-p 9001:9001  \
-d \
-e "MINIO_ROOT_USER=admin" \
-e "MINIO_ROOT_PASSWORD=admin123456" \
-v /root/minio-data:/data \
-v /root/minio-config:/root/.minio \
minio/minio server  /data --console-address ":9001"

• docker run：这是Docker命令行工具用来运行一个新容器的命令。

• –name minio_one：这个参数为容器指定了一个名称，这里名称被设置为minio_one。使用名称可以更方便地管理容器。

• p 9000:9000：这个参数将容器内的9000端口映射到宿主机的9000端口。MinIO服务默认使用9000端口提供API服务。

• -p 9001:9001：这个参数将容器内的9001端口映射到宿主机的9001端口。这是MinIO的控制台（Console）端口，用于访问MinIO的图形用户界面。

• -d：这个参数告诉Docker以“detached”模式运行容器，即在后台运行。

• -e “MINIO_ROOT_USER=admin”：设置环境变量MINIO_ROOT_USER，这是访问MinIO服务的用户名称，这里设置为admin。

• -e “MINIO_ROOT_PASSWORD=admin123456”：设置环境变量MINIO_ROOT_PASSWORD，这是访问MinIO服务的用户密码，这里设置为admin123456。

• -v /home/data:/data：这个参数将宿主机的目录/home/data:/data挂载到容器的/data目录。MinIO会将所有数据存储在这个目录。

• -v /root/config:/root/.minio：这个参数将宿主机的目录/root/minio-config挂载到容器的/root/.minio目录。这个目录用于存储MinIO的配置文件和数据。

• minio/minio：这是要运行的Docker镜像的名称，这里使用的是官方发布的MinIO镜像。

• server /data：这是传递给MinIO程序的命令行参数，告诉MinIO以服务器模式运行，并且使用/data目录作为其数据存储位置。

• –console-address “:9001”：这个参数指定MinIO控制台服务的监听地址和端口。在这个例子中，它设置为监听所有接口上的9001端口。

注意:文件上传时，需要调整-下Linux 服务器的时间与Windows 时间一致!

1
2
3
4
5
6
7
8
9
10
11
12

第一步:安装ntp服务
yum -y install ntp
第二步:开启开机启动服务
systemctl enable ntpd
第三步:启动服务
systemctl start ntpd
第四步:更改时区
timedatectl set-timezone Asia/Shanghai
第五步:启用ntp同步
timedatectl set-ntp yes
第六步:同步时间
ntpq -p

如果启动不了，那么就重构主义，推了重建

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 强制删除旧容器（保留数据卷）
docker rm -f minio_one

# 重新运行 MinIO 容器（使用正确的镜像名称 minio/minio）
docker run \
--name minio_one \
-p 9000:9000 \
-p 9001:9001 \
-d \
-e "MINIO_ROOT_USER=admin" \
-e "MINIO_ROOT_PASSWORD=admin123456" \
-v /root/minio-data:/data \
-v /root/minio-config:/root/.minio \
minio/minio server /data --console-address ":9001"

nacos

• 开启nacos

bash /root/nacos/bin/startup.sh -m standalone

• 关闭nacos

bash /root/nacos/bin/shutdown.sh

导入数据库内容

• 只需要在 DataGrip 连接上服务器或者本地的数据库

• 然后再把所需要的数据库和表创建好，数据导入进去

逻辑删除

• 物理删除是与之前一样，直接把数据删除，但这样不方便我们恢复数据，所以 mybatis-plus 有一种删除叫逻辑删除

• 我们可以在数据表加一列属性表示为逻辑删除，值为0表示没有删除，值为1表示删除，方便我们恢复数据

官方文档：https://baomidou.com/guides/logic-delete/

第一种方法：

1
2
3
4
5
6
7

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: isDelete #默认deleted
      logic-delete-value: 1
      logic-not-delete-value: 0
      id-type: auto

第二种方法：
添加@TableLogic注解

1
2
3
4
5
6
7
8
9
10

@Data
public class User{
。。。
    /**
     * 1删除0正常
     */
    @TableLogic(value = "1",delval = "0")
    private Integer isDelete;
。。。
}

添加完后再使用mp已经封装好的语句都会加上 where deleted = 0

分页查询

• 实现分页查询前需要配置分页插件

• 分页插件：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  @Configuration @MapperScan("scan.your.mapper.package") public class MybatisPlusConfig { /** * 添加分页插件 */ @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL)); // 如果配置多个插件, 切记分页最后添加 // 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType return interceptor; } }

导入配置文件

• 两种导入模式

第一种：像之前一样一条一条创建

第二种：把文件打成压缩包，但是压缩包名称要与组的名字相同（默认是 DEFAULT_GROUP）
![[Pasted image 20250418214153.png]]

客户端登录

微信小程序登录流程

• 官方文档：https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/login.html

![[Pasted image 20250419174655.png]]

微信小程序登录接口

• 这是接下来需要实现的步骤

项目工程结构：
![[Pasted image 20250419180421.png]]

准备工作

• **导入微信工具包相关依赖

在 service-customer 中引入依赖

1
2
3
4

<dependency>  
    <groupId>com.github.binarywang</groupId>  
    <artifactId>weixin-java-miniapp</artifactId>  
</dependency>

• **修改 nacos 配置中心文件

  • 因为查看官方文档可以看到我们后端请求腾讯接口需要三个值：小程序id、密钥和临时票据code，所以我们需要去 nacos 修改配置文件，把密钥和小程序id先作配置

  • 注意查看项目配置文件 bootstrap.properties 里 nacos 的 IP 与端口是否正确

• 创建配置类来读取配置文件信息

在 service-customer 创建包config，创建类来读取配置文件中的内容

1
2
3
4
5
6
7
8

@Component
@Data
//从配置文件中读取 wx.miniapp 前缀下的字段
@ConfigurationProperties(prefix = "wx.miniapp")
public class WxConfigProperties {
    private String appId;
    private String secret;
}

创建微信工具包对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@Component
public class WxConfigOperator {

    @Autowired
    private WxConfigProperties wxConfigProperties;

    @Bean
    public WxMaService wxMaService() {
        WxMaDefaultConfigImpl config = new WxMaDefaultConfigImpl();
        config.setAppid(wxConfigProperties.getAppId());
        config.setSecret(wxConfigProperties.getSecret());

        WxMaService service = new WxMaServiceImpl();
        service.setWxMaConfig(config);
        return service;
    }
}

功能实现-基础功能

• 在 service-customer 的 CustomerInfoController

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  @Slf4j @RestController @RequestMapping("/customer/info") @SuppressWarnings({"unchecked", "rawtypes"}) public class CustomerInfoController { @Autowired private CustomerInfoService customerInfoService; // 微信小程序登录接口 @Operation(summary = "小程序授权登录") @GetMapping("login/{code}") public Result<Long> longin(@PathVariable String code) { return Result.ok(customerInfoService.login(code)); } }

• service实现接口

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

  @Slf4j @Service @SuppressWarnings({"unchecked", "rawtypes"}) public class CustomerInfoServiceImpl extends ServiceImpl<CustomerInfoMapper, CustomerInfo> implements CustomerInfoService { @Autowired private WxMaService wxMaService; @Autowired private CustomerInfoMapper customerInfoMapper; @Autowired private CustomerLoginLogMapper customerLoginLogMapper; //微信小程序登录 @Override public Long login(String code) { String openid = null; // 获取code值，通过微信工具包对象，获取唯一标识openId try { WxMaJscode2SessionResult sessionInfo = wxMaService.getUserService().getSessionInfo(code); openid = sessionInfo.getOpenid(); } catch (WxErrorException e) { throw new RuntimeException(e); } // 用openId查询数据库是否存在 // 如果openId不存在返回null，如果存在返回记录 LambdaQueryWrapper<CustomerInfo> wrapper = new LambdaQueryWrapper(); wrapper.eq(CustomerInfo::getWxOpenId, openid); CustomerInfo customerInfo = customerInfoMapper.selectOne(wrapper); // 如果不存在，也就是第一次登陆，添加信息到用户表 if (customerInfo == null) { customerInfo = new CustomerInfo(); //用当前时间戳作为昵称 customerInfo.setNickname(String.valueOf(System.currentTimeMillis())); //设置默认头像 customerInfo.setAvatarUrl("https://oss.aliyuncs.com/aliyun_id_photo_bucket/default_handsome.jpg"); //把openId存入用户表 customerInfo.setWxOpenId(openid); customerInfoMapper.insert(customerInfo); } // 记录登录日志 CustomerLoginLog loginLog = new CustomerLoginLog(); loginLog.setCustomerId(customerInfo.getId()); loginLog.setMsg("小程序登录"); customerLoginLogMapper.insert(loginLog); // 最后返回用户id return customerInfo.getId(); } }

功能实现-远程调用

• service-customer-client 定义接口

  1 2 3 4 5 6 7

  @FeignClient(value = "service-customer") public interface CustomerInfoFeignClient { @GetMapping("/customer/info/login/{code}") public Result<Long> longin(@PathVariable String code); }

• 在 web-customer 进行远程调用
  controller：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  @Slf4j @Tag(name = "客户API接口管理") @RestController @RequestMapping("/customer") @SuppressWarnings({"unchecked", "rawtypes"}) public class CustomerController { @Autowired private CustomerService customerInfoService; @Operation(summary = "小程序授权登录") @GetMapping("/login/{code}") public Result<String> wxLogin(@PathVariable String code) { return Result.ok(customerInfoService.login(code)); } }

service：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class CustomerServiceImpl implements CustomerService {

    // 注入远程调用
    @Autowired
    private CustomerInfoFeignClient client;

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public String login(String code) {

        // 拿着code进行远程调用，返回用户id
        Result<Long> longin = client.longin(code);

        // 如果返回失败了。返回错误信息
        Integer code1 = longin.getCode();
        if(code1 != 200){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }

        // 获取远程调用的用户id
        Long customerId = longin.getData();

        // 判断返回用户id是否为空，为空则返回错误提示
        if(customerId == null){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }

        // 把用户id放到Redis中，设置过期时间
        String token = UUID.randomUUID().toString();

        // 返回token
        redisTemplate.opsForValue().set(RedisConstant.USER_LOGIN_KEY_PREFIX+token,
                customerId.toString(),
                RedisConstant.USER_LOGIN_KEY_TIMEOUT,
                TimeUnit.SECONDS);
        return token;
    }
}

功能实现-测试

• 运行乘客端微信小程序（微信开发者工具）

• 启动后端服务

  • 启动网关

  • 启动 service-customer 服务

  • 启动 web-customer 服务

把用到的配置文件都检查一遍，重点看看IP地址和开放端口，以及MySQL的远程用户(就是因为这个问题，后面用映射成localhost解决了)

获取客户端登录信息

service-customer 接口

• Controller

  1 2 3 4 5 6

  @Operation(summary = "获取客户端登录信息") @GetMapping("/getCustomerLoginInfo/{customerId}") public Result<CustomerLoginVo> getCustomerLoginInfo(@PathVariable Long customerId) { CustomerLoginVo customerLoginVo = customerInfoService.getCustomerInfoService(customerId); return Result.ok(customerLoginVo); }

• service

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  @Override public CustomerLoginVo getCustomerInfoService(Long customerId) { // 根据用户id查询用户信息 // LambdaQueryWrapper<CustomerInfo> wrapper = new LambdaQueryWrapper(); // wrapper.eq(CustomerInfo::getId, customerId); // CustomerInfo customerInfo = customerInfoMapper.selectOne(wrapper); CustomerInfo info = customerInfoMapper.selectById(customerId); if (info == null) { throw new RuntimeException("用户不存在"); } // 封装到customerLoginVo对象 CustomerLoginVo customerLoginVo = new CustomerLoginVo(); // springboot的工具类，可以把第一个对象的属性复制到第二个对象的同名属性中 BeanUtils.copyProperties(info, customerLoginVo); /* * 还有一个属性需要手动拷贝，判断是否存在手机号 * StringUtils.hasText(info.getPhone())判断字符串是否有值 */ customerLoginVo.setIsBindPhone(StringUtils.hasText(info.getPhone())); // 返回对象 return customerLoginVo; }

web-customer 接口

• controller

  1 2 3 4 5 6 7 8

  @Operation(summary = "获取客户登录信息") @GetMapping("/getCustomerLoginInfo") public Result<CustomerLoginVo> getCustomerLoginInfo(@RequestHeader(value = "token") String token) { CustomerLoginVo customerLoginVo = customerInfoService.getCustomerLoginInfo(token); // 返回用户对象 return Result.ok(customerLoginVo); }

• service

  • 这里的token要和前面设置的一样
  • redisTemplate.opsForValue().get() 就是把redis当成一个map容器，通过键值对的方式来存储或查询

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

    @Override public CustomerLoginVo getCustomerLoginInfo(String token) { /* * 从请求头中获取token字符串 * 根据token查询redis */ String customerId = (String) redisTemplate.opsForValue().get(RedisConstant.USER_LOGIN_KEY_PREFIX+token); // 根据用户id进行远程调用，获取用户信息 if(!StringUtils.hasText(customerId)){ throw new GuiguException(ResultCodeEnum.DATA_ERROR); } Result<CustomerLoginVo> customerLoginInfo = client.getCustomerLoginInfo(Long.parseLong(customerId)); Integer code = customerLoginInfo.getCode(); if(code != 200){ throw new GuiguException(ResultCodeEnum.DATA_ERROR); } CustomerLoginVo data = customerLoginInfo.getData(); if(data == null){ throw new GuiguException(ResultCodeEnum.DATA_ERROR); } return data; }

登录校验

这里选用 AOP面向切面加自定义注解完成，有想过用拦截器来做，但是路径太多，懒得配置了（高情商，更希望学习底层知识）

创建自定义注解

1
2
3
4
5

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginDetection {
    
}

创建切面类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

@Component
@Aspect
public class LoginAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    // 环绕通知，运行前后都触发
    // 切入点表达式，用来指定那些规则的方法进行增强
    @Around("execution(* com.atguigu.daijia.*.controller.*.*(..)) && @annotation(loginDetection)")
    public Object login(ProceedingJoinPoint proceedingJoinPoint,
                        LoginDetection loginDetection) throws Throwable {

        // 获取request对象，并且从请求头获取token
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) requestAttributes;

        String token = sra.getRequest().getHeader("token");


        // 判断token是否有效，如果为空或过期，返回登录提示
        if(!StringUtils.hasText(token)){
            throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
        }

        // token不为空，查询redis、对应用户id，把用户id放到ThreadLocal里面
        String customerId = (String) redisTemplate.opsForValue().get(RedisConstant.USER_LOGIN_KEY_PREFIX + token);
        
        if(StringUtils.hasText(customerId)){
            AuthContextHolder.setUserId(Long.parseLong(customerId));
        }
        
        // 执行目标方法
        return proceedingJoinPoint.proceed();
    }
}

把之前的getCustomerLoginInfo用上注解

在web-customer中的service里 getCustomerLoginInfo 做修改，用上我们刚刚写的注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Operation(summary = "获取客户登录信息")
    @LoginDetection
    @GetMapping("/getCustomerLoginInfo")
    public Result<CustomerLoginVo> getCustomerLoginInfo() {

        // 从ThreadLocal获取用户id
        Long userId = AuthContextHolder.getUserId();

        // 调用service
        CustomerLoginVo customerLoginVo = customerInfoService.getCustomerInfo(userId);

        // 返回用户对象
        return Result.ok(customerLoginVo);
    }

service

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Override
public CustomerLoginVo getCustomerInfo(Long customerId) {

	Result<CustomerLoginVo> customerLoginInfo = client.getCustomerLoginInfo(customerId);
	Integer code = customerLoginInfo.getCode();
	if(code != 200){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	CustomerLoginVo data = customerLoginInfo.getData();
	if(data == null){
		throw new GuiguException(ResultCodeEnum.DATA_ERROR);
	}
	return data;
}

获取乘客手机号

可恶，写完的时候发现个人版的微信开发无法使用这个，白写，最后不做判断直接改成true了

controller

1
2
3
4
5

@Operation(summary = "更新客户微信手机号码")
@PostMapping("/updateWxPhoneNumber")
public Result<Boolean> updateWxPhoneNumber(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) {
	return Result.ok(customerInfoService.updateWxPhoneNumber(updateWxPhoneForm));
}

service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 更新客户微信手机号码
@Override
public Boolean updateWxPhoneNumber(UpdateWxPhoneForm updateWxPhoneForm) {

	// 根据code查询用户信息
	try {
		WxMaPhoneNumberInfo phoneNoInfo = wxMaService.getUserService().getPhoneNoInfo(updateWxPhoneForm.getCode());

		// 更新用户信息
		Long customerId = updateWxPhoneForm.getCustomerId();
		CustomerInfo customerInfo = customerInfoMapper.selectById(customerId);
		customerInfo.setPhone(phoneNoInfo.getPhoneNumber());
		customerInfoMapper.updateById(customerInfo);

		return true;
	} catch (WxErrorException e) {
		throw new RuntimeException(e);
	}
}

web-customer

• controller
  企业版

  1 2 3 4 5 6 7

  @Operation(summary = "更新用户微信手机号") @LoginDetection @PostMapping("/updateWxPhone") public Result updateWxPhone(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) { updateWxPhoneForm.setCustomerId(AuthContextHolder.getUserId()); return Result.ok(customerInfoService.updateWxPhoneNumber(updateWxPhoneForm)); }

个人版：

1
2
3
4
5
6
7

@Operation(summary = "更新用户微信手机号")
@LoginDetection
@PostMapping("/updateWxPhone")
public Result updateWxPhone(@RequestBody UpdateWxPhoneForm updateWxPhoneForm) {
	updateWxPhoneForm.setCustomerId(AuthContextHolder.getUserId());
	return Result.ok(true);
}

• service

  1 2 3 4 5

  @Override public boolean updateWxPhoneNumber(UpdateWxPhoneForm updateWxPhoneForm) { Result<Boolean> booleanResult = client.updateWxPhoneNumber(updateWxPhoneForm); return true; }

司机端登录

司机开启接单的条件：

1、登录

2、认证通过

3、建立了腾讯云人员库人员

4、当日验证了人脸识别

准备工作与流程

• 准备共奏

因为司机端要完成认证模块，比如身份证，驾驶证之类的，所以我们需要用到腾讯云的对象存储COS
还有腾讯云的OCR来识别身份证和驾驶证

• 流程如下
  • 司机端登录功能
  • 获取用户信息
  • 腾讯云对象存储COS
  • 上传信息接口
  • 腾讯云OCR，识别身份证与驾驶证
  • 人脸识别

• 修改项目配置文件和Nacos里面配置文件内容

• 创建类，读取配置文件内容，微信小程序id和秘钥，这个跟客户端的一样，直接复制过来

  1 2 3 4 5 6 7

  @Component @Data @ConfigurationProperties(prefix = "wx.miniapp") public class WxConfigProperties { private String appId; private String secret; }

• 创建类，初始化微信工具包相关对象

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  @Component public class WxConfigOperator {     @Autowired     private WxConfigProperties wxConfigProperties;     @Bean     public WxMaService wxMaService() {         //微信小程序id和秘钥         WxMaDefaultConfigImpl wxMaConfig = new WxMaDefaultConfigImpl();         wxMaConfig.setAppid(wxConfigProperties.getAppId());         wxMaConfig.setSecret(wxConfigProperties.getSecret());         WxMaService service = new WxMaServiceImpl();         service.setWxMaConfig(wxMaConfig);         return service;     } }

司机端登录功能

这个步骤跟之前客户端差不多

• service：
  • 就是获取code，然后通过code加密钥和小程序id去获取用户的唯一表示openid
  • 判断这个用户是不是第一次登录
  • 是的话初始化用户
  • 返回id
• web-service:
  • 获取code，调用service
  • 远程调用获取数据
  • 生成token
  • 放入redis
  • 返回token

service-drive

DriverInfoController

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Slf4j
@Tag(name = "司机API接口管理")
@RestController
@RequestMapping(value="/driver/info")
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverInfoController {

    @Autowired
    private DriverInfoService driverInfoService;

    @Operation(summary = "小程序授权登录")
    @GetMapping("/login/{code}")
    public Result<Long> login(@PathVariable("code") String code) {
        return Result.ok(driverInfoService.login(code));
    }
}

DriverInfoServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverInfoServiceImpl extends ServiceImpl<DriverInfoMapper, DriverInfo> implements DriverInfoService {

    @Autowired
    private WxMaService wxMaService;

    @Autowired
    private DriverInfoMapper driverInfoMapper;

    @Autowired
    private DriverSetMapper driverSetMapper;

    @Autowired
    private DriverAccountMapper driverAccountMapper;

    @Autowired
    private DriverLoginLogMapper driverLoginLogMapper;

    // 小程序授权登录
    @Override
    public Long login(String code) {
        try {
            // 通过code+密钥+小程序id获取用户唯一标识openid
            WxMaJscode2SessionResult sessionInfo = wxMaService.getUserService().getSessionInfo(code);
            String openid = sessionInfo.getOpenid();

            // 根据openid查询用户信息
            LambdaQueryWrapper<DriverInfo> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(DriverInfo::getWxOpenId, openid);
            DriverInfo driverInfo = driverInfoMapper.selectOne(wrapper);

            if(driverInfo == null){
                // 添加司机基本信息
                driverInfo = new DriverInfo();
                driverInfo.setNickname(String.valueOf(System.currentTimeMillis()));
                driverInfo.setAvatarUrl("https://oss.aliyuncs.com/aliyun_id_photo_bucket/default_handsome.jpg");
                driverInfo.setWxOpenId(openid);
                driverInfoMapper.insert(driverInfo);

                // 初始化司机设置
                DriverSet driverSet = new DriverSet();
                driverSet.setDriverId(driverInfo.getId());
                driverSet.setOrderDistance(new BigDecimal(0));//0：无限制
                driverSet.setAcceptDistance(new BigDecimal(SystemConstant.ACCEPT_DISTANCE));//默认接单范围：5公里
                driverSet.setIsAutoAccept(0);//0：否 1：是
                driverSetMapper.insert(driverSet);

                // 初始化司机账户信息
                DriverAccount driverAccount = new DriverAccount();
                driverAccount.setDriverId(driverInfo.getId());
                driverAccountMapper.insert(driverAccount);
            }

            // 更新登录日志
            DriverLoginLog loginLog = new DriverLoginLog();
            loginLog.setDriverId(driverInfo.getId());
            loginLog.setMsg("小程序登录");
            driverLoginLogMapper.insert(loginLog);

            // 返回用户id
            return driverInfo.getId();
        } catch (WxErrorException e) {
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
    }
}

service-drive-client

1
2
3
4
5
6
7

@FeignClient(value = "service-driver")
public interface DriverInfoFeignClient {

    // 小程序授权登录
    @GetMapping("/driver/info/login/{code}")
    public Result<Long> login(@PathVariable("code") String code);
}

web-drive

controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Slf4j
@Tag(name = "司机API接口管理")
@RestController
@RequestMapping(value="/driver")
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverController {

    @Autowired
    private DriverService driverService;

    @Operation(summary = "小程序授权登录")
    @GetMapping("/login/{code}")
    public Result<String> login(@PathVariable("code") String code) {
        return Result.ok(driverService.login(code));
    }
}

service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class DriverServiceImpl implements DriverService {

    @Autowired
    private DriverInfoFeignClient driverInfoFeignClient;

    @Autowired
    private RedisTemplate redisTemplate;

    // 小程序授权登录
    @Override
    public String login(String code) {
        Result<Long> result = driverInfoFeignClient.login(code);
        if(result.getCode() != 200){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
        Long data = result.getData();
        if(data == null){
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
        String token = UUID.randomUUID().toString().replace("-","");
        redisTemplate.opsForValue().set(RedisConstant.USER_LOGIN_KEY_PREFIX + token,
                data.toString(),
                RedisConstant.USER_LOGIN_KEY_TIMEOUT,
                TimeUnit.SECONDS);

        return token;
    }
}

获取登录司机信息

service-driver

controller

1
2
3
4
5
6

@Operation(summary = "获取司机登录信息")  
@GetMapping("/getDriverLoginInfo/{driverId}")  
public Result<DriverLoginVo> getDriverInfo(@PathVariable("driverId") long driverId) {  
    DriverLoginVo driverLoginVo = driverInfoService.getDriverInfo(driverId);  
    return Result.ok(driverLoginVo);  
}

service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 获取司机登录信息
@Override
public DriverLoginVo getDriverInfo(long driverId) {
	// 通过id查询司机信息
	DriverInfo driverInfo = driverInfoMapper.selectById(driverId);
	
	// 赋予到vo对象中
	DriverLoginVo driverLoginVo = new DriverLoginVo();
	BeanUtils.copyProperties(driverInfo, driverLoginVo);

	// 查询是否需要建档人脸识别
	String faceModelId = driverInfo.getFaceModelId();
	boolean isArchiveFace = StringUtils.hasText(faceModelId);
	driverLoginVo.setIsArchiveFace(isArchiveFace);
	return driverLoginVo;
}

service-driver-client

1
2
3
4
5
6
7
8
9
10
11

@FeignClient(value = "service-driver")
public interface DriverInfoFeignClient {

    // 小程序授权登录
    @GetMapping("/driver/info/login/{code}")
    public Result<Long> login(@PathVariable("code") String code);

    // 获取登录司机信息
    @GetMapping("/driver/info/getDriverLoginInfo/{driverId}")
    public Result<DriverLoginVo> getDriverInfo(@PathVariable("driverId") long driverId);
}

web-driver

controller

1
2
3
4
5
6

@Operation(summary = "获取登录司机信息")
@LoginDetection
@GetMapping("/getDriverLoginInfo")
public Result<DriverLoginVo> getDriverLoginInfo() {
	return Result.ok(driverService.getDriverLoginVo());
}

service

1
2
3
4
5
6

@Override
public DriverLoginVo getDriverLoginVo() {
	Long driverId = AuthContextHolder.getUserId();
	Result<DriverLoginVo> driverInfo = driverInfoFeignClient.getDriverInfo(driverId);
	return driverInfo.getData();
}

测试一下前面的代码

• 打开微信开发者工具
• 改好相关配置文件
• nacos
• 启动后端服务
  • 网关服务service-gateway
  • 司机端基础服务service-driver
  • 对外访问服务web-driver

可恶，在这里前面web-driver里面controller的路径写错了，一直访问不上，还有nacos里面的配置忘记修改成映射后的端口

开通腾讯云对象存储COS

准备工作

• 注册并实名腾讯云
• 找到对象存储
• 创建储存桶
• 创建并保存密钥和id

思路

在 web-driver：

• 获取文件以及存放路径
• 远程调用实现文件上传
• 返回 vo 对象

在 service-driver：

• 导入依赖
• 获取上传文件及路径
• 修改配置文件
• 基于腾讯云官方文档调用实现上传
• 返回 vo 对象

注意点：因为保密隐私，我们这里的存储桶肯定是私密的，但是我们又要让用户能看到上传后的结果，因此我们需要创建一个临时地址，让客户看到存储内容

web-service

• controller

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  @Tag(name = "上传管理接口") @RestController @RequestMapping("file") public class FileController { @Autowired private CosService cosService; // 文件上传接口 @Operation(summary = "上传") @LoginDetection @PostMapping("/upload") public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file, @RequestParam(value = "path", defaultValue = "auth") String path) { CosUploadVo cosUploadVo = cosService.uploadFile(file, path); return Result.ok(cosUploadVo); } }

• service

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  @Slf4j @Service @SuppressWarnings({"unchecked", "rawtypes"}) public class CosServiceImpl implements CosService { @Autowired private CosFeignClient cosFeignClient; // 文件上传接口 @Override public CosUploadVo uploadFile(MultipartFile file, String path) { // 远程调用获取vo Result<CosUploadVo> result = cosFeignClient.upload(file, path); CosUploadVo cosUploadVo = result.getData(); return cosUploadVo; } }

service-driver-client

1
2
3
4
5
6
7
8
9
10
11

@FeignClient(value = "service-driver")
public interface CosFeignClient {

    /*
    * 文件上传
    * MediaType 表示上传类型
    */
    @PostMapping(value = "/cos/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file,
                                      @RequestParam(value = "path") String path);
}

service-driver

• 导入依赖

  1 2 3 4 5

  <dependency> <groupId>com.qcloud</groupId> <artifactId>cos_api</artifactId> <version>5.6.227</version> </dependency>

• 修改配置文件

• 创建类读取配置文件内容

  1 2 3 4 5 6 7 8 9

  @Data @Component @ConfigurationProperties(prefix = "tencent.cloud") public class TencentCloudProperties { private String secretId; private String secretKey; private String region; private String bucketPrivate; }

• controller

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  @Slf4j @Tag(name = "腾讯云cos上传接口管理") @RestController @RequestMapping(value="/cos") @SuppressWarnings({"unchecked", "rawtypes"}) public class CosController { @Autowired private CosService cosService; @Operation(summary = "上传") @PostMapping("/upload") public Result<CosUploadVo> upload(@RequestPart("file") MultipartFile file, @RequestParam("path") String path) { CosUploadVo cosUploadVo = cosService.upload(file, path); return Result.ok(cosUploadVo); } }

• service

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

  @Slf4j @Service @SuppressWarnings({"unchecked", "rawtypes"}) public class CosServiceImpl implements CosService { @Autowired private TencentCloudProperties tencentCloudProperties; // 文件上传 @Override public CosUploadVo upload(MultipartFile file, String path) { // 获取cos客户端 COSClient cosClient = getCosClient(); // 文件上传 // 设置文件元数据信息 ObjectMetadata metadata = new ObjectMetadata(); metadata.setContentLength(file.getSize()); metadata.setContentEncoding("UTF-8"); metadata.setContentType(file.getContentType()); // 向储存桶保存文件 String fileType = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".")); //文件后缀名 String uploadPath = "/driver/" + path + "/" + UUID.randomUUID().toString().replaceAll("-", "") + fileType; // 01.jpg // /driver/auth/0o98754.jpg PutObjectRequest putObjectRequest = null; try { //1 bucket名称 //2 putObjectRequest = new PutObjectRequest(tencentCloudProperties.getBucketPrivate(), uploadPath, file.getInputStream(), metadata); } catch (IOException e) { throw new RuntimeException(e); } putObjectRequest.setStorageClass(StorageClass.Standard); PutObjectResult putObjectResult = cosClient.putObject(putObjectRequest); //上传文件 cosClient.shutdown(); //返回vo对象 CosUploadVo cosUploadVo = new CosUploadVo(); cosUploadVo.setUrl(uploadPath); // 图片临时访问回显url cosUploadVo.setShowUrl(this.getImagerUrl(uploadPath)); return cosUploadVo; }

提取CosClient

1
2
3
4
5
6
7
8
9
10
11
12
13
14

private COSClient getCosClient() {
	// 1 初始化用户身份信息（secretId, secretKey）。
	String secretId = tencentCloudProperties.getSecretId();
	String secretKey = tencentCloudProperties.getSecretKey();
	COSCredentials cred = new BasicCOSCredentials(secretId, secretKey);
	// 2 设置 bucket 的地域
	Region region = new Region(tencentCloudProperties.getRegion());
	ClientConfig clientConfig = new ClientConfig(region);
	// 这里建议设置使用 https 协议
	clientConfig.setHttpProtocol(HttpProtocol.https);
	// 3 生成 cos 客户端。
	COSClient cosClient = new COSClient(cred, clientConfig);
	return cosClient;
}

获取临时签名url

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@Override
public String getImagerUrl(String path) {
	if(!StringUtils.hasText(path)){
		return "";
	}
	COSClient cosClient = getCosClient();
	GeneratePresignedUrlRequest request =
			new GeneratePresignedUrlRequest(tencentCloudProperties.getBucketPrivate(),
					path,
					HttpMethodName.GET);
	// 设置临时URL有效期
	DateTime dateTime = new DateTime().plusMinutes(15);
	request.setExpiration(dateTime.toDate());
	// 调用方法获取
	URL url = cosClient.generatePresignedUrl(request);
	cosClient.shutdown();
	return url.toString();
}

这一大段看着很复杂，其实大部分都是腾讯云官方文档里面的内容，我们只需要修改一下参数即可

腾讯云身份证与驾驶证识别接口

思路

司机注册成功后，应该需要去实名认证，这里可以用到腾讯云的身份识别和云存储功能，身份证和驾驶证上传的步骤都差不多，这里就写在一起了

那我们现在计划很明确了

web-driver：

• 获取上传文件
• 远程调用获取认证信息
• 返回认证信息

service-driver：

• 上传认证图片
• 调用腾讯云相关接口完成认证
• 返回认证信息

service-driver

• controller：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  @Slf4j @Tag(name = "腾讯云识别接口管理") @RestController @RequestMapping(value="/ocr") @SuppressWarnings({"unchecked", "rawtypes"}) public class OcrController { @Autowired private OcrService ocrService; @Operation(summary = "身份证识别") @PostMapping("/idCardOcr") public Result<IdCardOcrVo> idCardOcr(@RequestPart("file") MultipartFile file) { IdCardOcrVo idCardOcrVo = ocrService.idCardOcr(file); return Result.ok(idCardOcrVo); } @Operation(summary = "驾驶证识别") @PostMapping("/driverLicenseOcr") public Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file") MultipartFile file) { DriverLicenseOcrVo driverLicenseOcrVo = ocrService.driverLicenseOcr(file); return Result.ok(driverLicenseOcrVo); } }

• service：
  导入依赖：

  1 2 3 4 5

  <dependency> <groupId>com.tencentcloudapi</groupId> <artifactId>tencentcloud-sdk-java</artifactId> <version>${tencentcloud.version}</version> </dependency>

看着代码很多，其实全都是从腾讯云官网拉过来修改配置的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class OcrServiceImpl implements OcrService {

    @Autowired
    private TencentCloudProperties tencentCloudProperties;

    @Autowired
    private CosService cosService;

    // 身份证识别
    @Override
    public IdCardOcrVo idCardOcr(MultipartFile file) {
        try{
            // file转换成base64
            byte[] base64 = Base64.encodeBase64(file.getBytes());
            String fileBase64 = new String(base64);
            // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密
            Credential cred = new Credential(tencentCloudProperties.getSecretId(),
                    tencentCloudProperties.getSecretKey());
            // 实例化一个http选项，可选的，没有特殊需求可以跳过
            HttpProfile httpProfile = new HttpProfile();
            httpProfile.setEndpoint("ocr.tencentcloudapi.com");
            // 实例化一个client选项，可选的，没有特殊需求可以跳过
            ClientProfile clientProfile = new ClientProfile();
            clientProfile.setHttpProfile(httpProfile);
            // 实例化要请求产品的client对象,clientProfile是可选的
            OcrClient client = new OcrClient(cred,tencentCloudProperties.getRegion(), clientProfile);
            // 实例化一个请求对象,每个接口都会对应一个request对象
            IDCardOCRRequest req = new IDCardOCRRequest();
            //设置文件
            req.setImageBase64(fileBase64);

            // 返回的resp是一个IDCardOCRResponse的实例，与请求对象对应
            IDCardOCRResponse resp = client.IDCardOCR(req);

            //转换为IdCardOcrVo对象
            IdCardOcrVo idCardOcrVo = new IdCardOcrVo();
            if (StringUtils.hasText(resp.getName())) {
                //身份证正面
                idCardOcrVo.setName(resp.getName());
                idCardOcrVo.setGender("男".equals(resp.getSex()) ? "1" : "2");
                idCardOcrVo.setBirthday(DateTimeFormat.forPattern("yyyy/MM/dd").parseDateTime(resp.getBirth()).toDate());
                idCardOcrVo.setIdcardNo(resp.getIdNum());
                idCardOcrVo.setIdcardAddress(resp.getAddress());

                //上传身份证正面图片到腾讯云cos
                CosUploadVo cosUploadVo = cosService.upload(file, "idCard");
                idCardOcrVo.setIdcardFrontUrl(cosUploadVo.getUrl());
                idCardOcrVo.setIdcardFrontShowUrl(cosUploadVo.getShowUrl());
            } else {
                //身份证反面
                //证件有效期："2010.07.21-2020.07.21"
                String idcardExpireString = resp.getValidDate().split("-")[1];
                idCardOcrVo.setIdcardExpire(DateTimeFormat.forPattern("yyyy.MM.dd").parseDateTime(idcardExpireString).toDate());
                //上传身份证反面图片到腾讯云cos
                CosUploadVo cosUploadVo = cosService.upload(file, "idCard");
                idCardOcrVo.setIdcardBackUrl(cosUploadVo.getUrl());
                idCardOcrVo.setIdcardBackShowUrl(cosUploadVo.getShowUrl());
            }
            return idCardOcrVo;
        } catch (Exception e) {
            throw new GuiguException(ResultCodeEnum.DATA_ERROR);
        }
    }

	//驾驶证识别  
	@Override  
	public DriverLicenseOcrVo driverLicenseOcr(MultipartFile file) {  
	    try{  
	        //图片转换base64格式字符串  
	        byte[] base64 = Base64.encodeBase64(file.getBytes());  
	        String fileBase64 = new String(base64);  
	  
	        // 实例化一个认证对象，入参需要传入腾讯云账户 SecretId 和 SecretKey，此处还需注意密钥对的保密  
	        Credential cred = new Credential(tencentCloudProperties.getSecretId(),  
	                tencentCloudProperties.getSecretKey());  
	        // 实例化一个http选项，可选的，没有特殊需求可以跳过  
	        HttpProfile httpProfile = new HttpProfile();  
	        httpProfile.setEndpoint("ocr.tencentcloudapi.com");  
	        // 实例化一个client选项，可选的，没有特殊需求可以跳过  
	        ClientProfile clientProfile = new ClientProfile();  
	        clientProfile.setHttpProfile(httpProfile);  
	        // 实例化要请求产品的client对象,clientProfile是可选的  
	        OcrClient client = new OcrClient(cred, tencentCloudProperties.getRegion(),  
	                clientProfile);  
	        // 实例化一个请求对象,每个接口都会对应一个request对象  
	        DriverLicenseOCRRequest req = new DriverLicenseOCRRequest();  
	        req.setImageBase64(fileBase64);  
	  
	        // 返回的resp是一个DriverLicenseOCRResponse的实例，与请求对象对应  
	        DriverLicenseOCRResponse resp = client.DriverLicenseOCR(req);  
	  
	        //封装到vo对象里面  
	        DriverLicenseOcrVo driverLicenseOcrVo = new DriverLicenseOcrVo();  
	        if (StringUtils.hasText(resp.getName())) {  
	            //驾驶证正面  
	            //驾驶证名称要与身份证名称一致  
	            driverLicenseOcrVo.setName(resp.getName());  
	            driverLicenseOcrVo.setDriverLicenseClazz(resp.getClass_());  
	            driverLicenseOcrVo.setDriverLicenseNo(resp.getCardCode());  
	            driverLicenseOcrVo.setDriverLicenseIssueDate(DateTimeFormat.forPattern("yyyy-MM-dd").parseDateTime(resp.getDateOfFirstIssue()).toDate());  
	            driverLicenseOcrVo.setDriverLicenseExpire(DateTimeFormat.forPattern("yyyy-MM-dd").parseDateTime(resp.getEndDate()).toDate());  
	  
	            //上传驾驶证反面图片到腾讯云cos  
	            CosUploadVo cosUploadVo = cosService.upload(file, "driverLicense");  
	            driverLicenseOcrVo.setDriverLicenseFrontUrl(cosUploadVo.getUrl());  
	            driverLicenseOcrVo.setDriverLicenseFrontShowUrl(cosUploadVo.getShowUrl());  
	        } else {  
	            //驾驶证反面  
	            //上传驾驶证反面图片到腾讯云cos  
	            CosUploadVo cosUploadVo =  cosService.upload(file, "driverLicense");  
	            driverLicenseOcrVo.setDriverLicenseBackUrl(cosUploadVo.getUrl());  
	            driverLicenseOcrVo.setDriverLicenseBackShowUrl(cosUploadVo.getShowUrl());  
	        }  
	  
	        return driverLicenseOcrVo;  
	    } catch (Exception e) {  
	        e.printStackTrace();  
	        throw new GuiguException(ResultCodeEnum.DATA_ERROR);  
	    }  
	}
}

service-client

1
2
3
4
5
6
7
8
9

@FeignClient(value = "service-driver")  
public interface OcrFeignClient {  
  
    @PostMapping(value = "/ocr/idCardOcr", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)  
    Result<IdCardOcrVo> idCardOcr(@RequestPart("file") MultipartFile file);  
  
    @PostMapping(value = "/ocr/driverLicenseOcr", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)  
    Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file") MultipartFile file);  
}

web-service

• controller

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

  @Slf4j @Tag(name = "腾讯云识别接口管理") @RestController @RequestMapping(value="/ocr") @SuppressWarnings({"unchecked", "rawtypes"}) public class OcrController { @Autowired private OcrService ocrService; @Operation(summary = "身份证识别") @LoginDetection @PostMapping("/idCardOcr") public Result<IdCardOcrVo> uploadDriverLicenseOcr(@RequestPart("file")MultipartFile file){ return Result.ok(ocrService.idCardOcr(file)); } @Operation(summary = "驾驶证识别") @LoginDetection @PostMapping("/driverLicenseOcr") public Result<DriverLicenseOcrVo> driverLicenseOcr(@RequestPart("file")MultipartFile file){ return Result.ok(ocrService.driverLicenseOcr(file)); } }

• serivce

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

  @Slf4j @Service @SuppressWarnings({"unchecked", "rawtypes"}) public class OcrServiceImpl implements OcrService { @Autowired private OcrFeignClient ocrFeignClient; // 身份证 @Override public IdCardOcrVo idCardOcr(MultipartFile file) { Result<IdCardOcrVo> ocrVoResult = ocrFeignClient.idCardOcr(file); return ocrVoResult.getData(); } // 驾驶证 @Override public DriverLicenseOcrVo driverLicenseOcr(MultipartFile file) { Result<DriverLicenseOcrVo> result = ocrFeignClient.driverLicenseOcr(file); return result.getData(); } }

获取司机认证信息

思路

司机登录后会进入认证界面，判单是否认证，进入认证界面是会显示回显的图片

其实这个很简单，因为腾讯云的那个文字识别会返回参数出来，我们只需要把回显地址返回回去就行

driver-service

• 通过id来传入回显地址

driver-web

• 调用该

service-driver

• controller

  1 2 3 4 5 6

  @Operation(summary = "获取司机认证信息") @GetMapping("/getDriverAuthInfo/{driverId}") public Result<DriverAuthInfoVo> getDriverAuthInfo(@PathVariable Long driverId) { DriverAuthInfoVo driverAuthInfoVo = driverInfoService.getDriverAuthInfo(driverId); return Result.ok(driverAuthInfoVo); }

• service

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

  ```java //获取司机认证信息 @Override public DriverAuthInfoVo getDriverAuthInfo(Long driverId) { DriverInfo driverInfo = driverInfoMapper.selectById(driverId); DriverAuthInfoVo driverAuthInfoVo = new DriverAuthInfoVo(); BeanUtils.copyProperties(driverInfo,driverAuthInfoVo); driverAuthInfoVo.setIdcardBackShowUrl(cosService.getImageUrl(driverAuthInfoVo.getIdcardBackUrl()));     driverAuthInfoVo.setIdcardFrontShowUrl(cosService.getImageUrl(driverAuthInfoVo.getIdcardFrontUrl()));     driverAuthInfoVo.setIdcardHandShowUrl(cosService.getImageUrl(driverAuthInfoVo.getIdcardHandUrl()));     driverAuthInfoVo.setDriverLicenseFrontShowUrl(cosService.getImageUrl(driverAuthInfoVo.getDriverLicenseFrontUrl()));     driverAuthInfoVo.setDriverLicenseBackShowUrl(cosService.getImageUrl(driverAuthInfoVo.getDriverLicenseBackUrl()));     driverAuthInfoVo.setDriverLicenseHandShowUrl(cosService.getImageUrl(driverAuthInfoVo.getDriverLicenseHandUrl()));     return driverAuthInfoVo; }

service-client

1
2

@GetMapping("/driver/info/getDriverAuthInfo/{driverId}")
Result<DriverAuthInfoVo> getDriverAuthInfo(@PathVariable("driverId") Long driverId);

web-serive

• controller

  1 2 3 4 5 6 7 8

  @Operation(summary = "获取司机认证信息") @GuiguLogin @GetMapping("/getDriverAuthInfo") public Result<DriverAuthInfoVo> getDriverAuthInfo() { //获取登录用户id，当前是司机id Long driverId = AuthContextHolder.getUserId(); return Result.ok(driverService.getDriverAuthInfo(driverId)); }

• serivce

  1 2 3 4 5 6 7

  //司机认证信息 @Override public DriverAuthInfoVo getDriverAuthInfo(Long driverId) { Result<DriverAuthInfoVo> authInfoVoResult = driverInfoFeignClient.getDriverAuthInfo(driverId); DriverAuthInfoVo driverAuthInfoVo = authInfoVoResult.getData(); return driverAuthInfoVo; }

修改司机认证信息

思路

前端点击提交后，后端需要更新客户认证信息
​    0: 未认证 【刚注册完为未认证状态】
​   1：审核中 【提交了认证信息后变为审核中】
​   2：认证通过 【后台审核通过】
​   -1：认证未通过【后台审核不通过】

这个和上面差不多，其他就不写了，就写一个service

1
2
3
4
5
6
7
8
9

// 更新司机认证信息
@Override
public boolean updateDriverAuthInfo(UpdateDriverAuthInfoForm update) {
	Long driverId = update.getDriverId();
	DriverInfo driverInfo = new DriverInfo();
	driverInfo.setId(driverId);
	BeanUtils.copyProperties(update, driverInfo);
	return this.updateById(driverInfo);
}

开通人脸识别

腾讯云文档：人脸识别_人脸搜索_人脸检测_人脸比对-腾讯云

1、开通腾讯云人脸识别
2、创建人员库

创建司机人脸模型

创建人脸识别模型之后，腾讯云返回模型id，获取模型id，更新到数据库表，但是因为这是调用腾讯云接口，所以如果之前已经有人拿这张图片创建过则不会创建新的模型id，而是返回之前创建的id

• 修改配置文件

• 修改配置类

  1 2 3 4 5 6 7 8 9 10 11 12

  @Data @Component @ConfigurationProperties(prefix = "tencent.cloud") public class TencentCloudProperties { private String secretId; private String secretKey; private String region; private String bucketPrivate; private String persionGroupId; }

• 根据腾讯云文档来实现代码 API Explorer - 云 API - 控制台

service-driver

后面都是只写重要的代码实现，一般的调用就不写了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// 创建司机人脸模型
@Override
public Boolean creatDriverFaceModel(DriverFaceModelForm driverFaceModelForm) {
	//根据司机id获取司机信息
	DriverInfo driverInfo =
			driverInfoMapper.selectById(driverFaceModelForm.getDriverId());
	try{
		Credential cred = new Credential(tencentCloudProperties.getSecretId(),
				tencentCloudProperties.getSecretKey());
		// 实例化一个http选项，可选的，没有特殊需求可以跳过
		HttpProfile httpProfile = new HttpProfile();
		httpProfile.setEndpoint("iai.tencentcloudapi.com");
		// 实例化一个client选项，可选的，没有特殊需求可以跳过
		ClientProfile clientProfile = new ClientProfile();
		clientProfile.setHttpProfile(httpProfile);
		// 实例化要请求产品的client对象,clientProfile是可选的
		IaiClient client = new IaiClient(cred, tencentCloudProperties.getRegion(),
				clientProfile);
		// 实例化一个请求对象,每个接口都会对应一个request对象
		CreatePersonRequest req = new CreatePersonRequest();
		//设置相关值
		req.setGroupId(tencentCloudProperties.getPersionGroupId());
		//基本信息
		req.setPersonId(String.valueOf(driverInfo.getId()));
		req.setGender(Long.parseLong(driverInfo.getGender()));
		req.setQualityControl(4L);
		req.setUniquePersonControl(4L);
		req.setPersonName(driverInfo.getName());
		req.setImage(driverFaceModelForm.getImageBase64());

		// 返回的resp是一个CreatePersonResponse的实例，与请求对象对应
		CreatePersonResponse resp = client.CreatePerson(req);
		// 输出json格式的字符串回包
		System.out.println(AbstractModel.toJsonString(resp));
		String faceId = resp.getFaceId();
		if(StringUtils.hasText(faceId)) {
			driverInfo.setFaceModelId(faceId);
			driverInfoMapper.updateById(driverInfo);
		}
	} catch (TencentCloudSDKException e) {
		e.printStackTrace();
		return false;
	}
	return true;
}

预估订单数据

查找客户端当前订单

当一个客户发起订单前先要查询是否有发起并且没有完成的订单，如果有订单未完成，则会弹出进行中的订单

预估驾驶路线

• 访问腾讯官网 https://lbs.qq.com/

• 进行注册，手机号或者微信或者其他方式

• 使用注册账号进行登录，找到控制台

• 在应用管理 – 我的应用 ，创建应用

• 在创建应用中，添加key

• 修改nacos配置文件

• 编写接口

下面实现接口，具体内容就是请求腾讯云提供的接口，按照接口传参数，然后返回需要的结果

腾讯官方文档：WebService API | 腾讯位置服务

• 编写配置类

  1 2 3 4 5 6 7 8

  @Configuration public class MyConfig { @Bean public RestTemplate restTemplate() { return new RestTemplate(); } }

• service

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

  @Slf4j @Service @SuppressWarnings({"unchecked", "rawtypes"}) public class MapServiceImpl implements MapService { @Autowired private RestTemplate restTemplate; @Value("${tencent.map.key}") private String key; //计算驾驶线路 @Override public DrivingLineVo calculateDrivingLine(CalculateDrivingLineForm calculateDrivingLineForm) { //请求腾讯提供接口，按照接口要求传递相关参数，返回需要结果 //使用HttpClient，目前Spring封装调用工具使用RestTemplate //定义调用腾讯地址 String url = "https://apis.map.qq.com/ws/direction/v1/driving/?from={from}&to={to}&key={key}"; //封装传递参数 Map<String,String> map = new HashMap(); //开始位置 // 经纬度：比如 北纬40 东京116 map.put("from",calculateDrivingLineForm.getStartPointLatitude()+","+calculateDrivingLineForm.getStartPointLongitude()); //结束位置 map.put("to",calculateDrivingLineForm.getEndPointLatitude()+","+calculateDrivingLineForm.getEndPointLongitude()); //key map.put("key",key); //使用RestTemplate调用 GET JSONObject result = restTemplate.getForObject(url, JSONObject.class, map); //处理返回结果 //判断调用是否成功 int status = Objects.requireNonNull(result).getIntValue("status"); if(status != 0) {//失败 throw new GuiguException(ResultCodeEnum.MAP_FAIL); } //获取返回路线信息 JSONObject route = result.getJSONObject("result").getJSONArray("routes").getJSONObject(0); //创建vo对象 DrivingLineVo drivingLineVo = new DrivingLineVo(); //预估时间 drivingLineVo.setDuration(route.getBigDecimal("duration")); //距离 6.583 == 6.58 / 6.59 drivingLineVo.setDistance(route.getBigDecimal("distance") .divide(new BigDecimal(1000)) .setScale(2, RoundingMode.HALF_UP)); //路线 drivingLineVo.setPolyline(route.getJSONArray("polyline")); return drivingLineVo; } }

预估订单金额

整合规则引擎Drools

• 引入依赖

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  <dependencies> <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-compiler</artifactId> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-decisiontables</artifactId> </dependency> <dependency> <groupId>org.drools</groupId> <artifactId>drools-mvel</artifactId> </dependency> </dependencies>

• 创建Drools配置类

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  @Configuration public class DroolsConfig { // 制定规则文件的路径 private static final String RULES_CUSTOMER_RULES_DRL = "rules/FeeRule.drl"; @Bean public KieContainer kieContainer() { KieServices kieServices = KieServices.Factory.get(); KieFileSystem kieFileSystem = kieServices.newKieFileSystem(); kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_CUSTOMER_RULES_DRL)); KieBuilder kb = kieServices.newKieBuilder(kieFileSystem); kb.buildAll(); KieModule kieModule = kb.getKieModule(); KieContainer kieContainer = kieServices.newKieContainer(kieModule.getReleaseId()); return kieContainer; } }

• 创建规则文件

封装费用规则接口

实体类

• 两个实体类，输入对象和输出对象

• 输入对象

  1 2 3 4 5 6 7 8 9 10 11 12

  @Data public class FeeRuleRequest { @Schema(description = "代驾里程")// swagger里面的描述 private BigDecimal distance; @Schema(description = "代驾时间") private String startTime; @Schema(description = "等候分钟") private Integer waitMinute; }

• 输出对象

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

  @Data public class FeeRuleResponse { @Schema(description = "总金额") private BigDecimal totalAmount; @Schema(description = "里程费") private BigDecimal distanceFee; @Schema(description = "等时费用") private BigDecimal waitFee; @Schema(description = "远程费") private BigDecimal longDistanceFee; @Schema(description = "基础里程（公里）") private BigDecimal baseDistance; @Schema(description = "基础里程费（元）") private BigDecimal baseDistanceFee; @Schema(description = "超出基础里程的里程（公里）") private BigDecimal exceedDistance; @Schema(description = "超出基础里程的价格（元/公里）") private BigDecimal exceedDistancePrice; @Schema(description = "基础等时分钟（分钟）") private Integer baseWaitMinute; @Schema(description = "超出基础等时的分钟（分钟）") private Integer exceedWaitMinute; @Schema(description = "超出基础分钟的价格（元/分钟）") private BigDecimal exceedWaitMinutePrice; @Schema(description = "基础远途里程（公里）") private BigDecimal baseLongDistance; @Schema(description = "超出基础远程里程的里程（公里）") private BigDecimal exceedLongDistance; @Schema(description = "超出基础远程里程的价格（元/公里）") private BigDecimal exceedLongDistancePrice; }

费用规则文件

1.起步价
00:00:00-06:59:59 19元(含3公里)
07:00:00-23:59:59 19元(含5公里)
2.里程费
超出起步里程后开始计算
00:00:00-06:59:59 4元/1公里
07:00:00-23:59:59 3元/1公里
3.等候费
等候10分钟后 1元/1分钟
4.远途费
订单行程超出12公里后每公里1元
5.计算总金额
订单总金额 = 基础里程费 + 超出基础里程的费 + 等候费 + 远程费

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179